home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / MPW Oberon 2.1168 / OInterfaces / OCEMessaging.mod < prev    next >
Encoding:
Text File  |  1995-08-10  |  34.0 KB  |  1,222 lines  |  [TEXT/MPS ]
  1. (*
  2.      File:        OCEMessaging.mod
  3.  
  4.      Contains:    Apple Open Collaboration Environment Messaging Interfaces.
  5.  
  6.      Version:    Technology:    AOCE Toolbox 1.02
  7.                  Package:    Universal Interfaces 2.1ß1 in “MPW Prerelease” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs.applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. *)
  19.  
  20. (*$TAGS-*)
  21. (*$CALLING PASCAL*)
  22. MODULE OCEMessaging;
  23.  
  24. IMPORT SYSTEM, Types, Memory, Files, DigitalSignature, OCE, OCEAuthDir;
  25.  
  26. (* $PUSH*)
  27. (* $ALIGN MAC68K*)
  28. (* $LibExport+*)
  29.  
  30. CONST
  31.     kIPMAnyPriority*                = 0;                            (* FOR FILTER ONLY *)
  32.     kIPMNormalPriority*            = 1;
  33.     kIPMLowPriority*                = 2;
  34.     kIPMHighPriority*            = 3;
  35.  
  36.     
  37. TYPE
  38.     IPMPriority* = Types.SignedByte;
  39.  
  40.  
  41. CONST
  42.     kIPMAtMark*                    = 0;
  43.     kIPMFromStart*                = 1;
  44.     kIPMFromLEOM*                = 2;
  45.     kIPMFromMark*                = 3;
  46.  
  47.     
  48. TYPE
  49.     IPMAccessMode* = INTEGER;
  50.  
  51.  
  52. CONST
  53.     kIPMUpdateMsgBit*            = 4;
  54.     kIPMNewMsgBit*                = 5;
  55.     kIPMDeleteMsgBit*            = 6;
  56.  
  57. (* Values of IPMNotificationType *)
  58.     kIPMUpdateMsgMask*            = ASH(1,kIPMUpdateMsgBit);
  59.     kIPMNewMsgMask*                = ASH(1,kIPMNewMsgBit);
  60.     kIPMDeleteMsgMask*            = ASH(1,kIPMDeleteMsgBit);
  61.  
  62.     
  63. TYPE
  64.     IPMNotificationType* = Types.SignedByte;
  65.  
  66.  
  67. CONST
  68.     kIPMSenderRStringTag*        = 0;
  69.     kIPMSenderRecordIDTag*        = 1;
  70.  
  71.     
  72. TYPE
  73.     IPMSenderTag* = INTEGER;
  74.  
  75.  
  76. CONST
  77.     kIPMFromDistListBit*            = 0;
  78.     kIPMDummyRecBit*                = 1;
  79.     kIPMFeedbackRecBit*            = 2;                            (* should be redirected to feedback queue *)
  80.     kIPMReporterRecBit*            = 3;                            (* should be redirected to reporter original queue *)
  81.     kIPMBCCRecBit*                = 4;                            (* this recipient is blind to all recipients of message *)
  82.  
  83. (* Values of OCERecipientOffsetFlags *)
  84.     kIPMFromDistListMask*        = ASH(1,kIPMFromDistListBit);
  85.     kIPMDummyRecMask*            = ASH(1,kIPMDummyRecBit);
  86.     kIPMFeedbackRecMask*            = ASH(1,kIPMFeedbackRecBit);
  87.     kIPMReporterRecMask*            = ASH(1,kIPMReporterRecBit);
  88.     kIPMBCCRecMask*                = ASH(1,kIPMBCCRecBit);
  89.  
  90.     
  91. TYPE
  92.     OCERecipientOffsetFlags* = Types.SignedByte;
  93.  
  94.     OCECreatorType* = RECORD
  95.         msgCreator*:                Types.OSType;
  96.         msgType*:                Types.OSType;
  97.     END;
  98.  
  99.  
  100. CONST
  101.     kIPMTypeWildCard*            = LONG("ipmw");
  102.     kIPMFamilyUnspecified*        = 0;
  103.     kIPMFamilyWildCard*            = $3F3F3F3F;                    (* '??POINTER TO  
  104.  
  105.     * well known signature *)
  106.     kIPMSignature*                = LONG("ipms");                        (* base type 
  107.  
  108.     * well known message types *)
  109.     kIPMReportNotify*            = LONG("rptn");                        (* routing feedback
  110.  
  111.     * well known message block types *)
  112.     kIPMEnclosedMsgType*            = LONG("emsg");                        (* enclosed (nested) message *)
  113.     kIPMReportInfo*                = LONG("rpti");                        (* recipient information *)
  114.     kIPMDigitalSignature*        = LONG("dsig");
  115.  
  116. (* Values of IPMMsgFormat *)
  117.     kIPMOSFormatType*            = 1;
  118.     kIPMStringFormatType*        = 2;
  119.  
  120.     
  121. TYPE
  122.     IPMMsgFormat* = INTEGER;
  123.  
  124.     IPMStringMsgType* = Types.Str32;
  125.  
  126.     TheType* = RECORD
  127.         (*ΔΔ CASE INTEGER OF
  128.         0: ( *)
  129.     END;
  130.     TheTypeCreator* = RECORD(TheType)
  131.             msgOSType*:                    OCECreatorType;
  132.            (*ΔΔ );
  133.         1: ( *)
  134.     END;
  135.     TheTypeString* = RECORD(TheType)
  136.             msgStrType*:                    IPMStringMsgType;
  137.            (*ΔΔ );*)
  138.     END;
  139.  
  140.     IPMMsgType* = RECORD
  141.         format*:                    IPMMsgFormat;                            (* IPMMsgFormat*)
  142.         theType*:                TheType;
  143.     END;
  144.  
  145. (*
  146. Following are the known extension values for IPM addresses handled by Apple.
  147. We define the definition of the entn extension below.
  148. *)
  149.  
  150. CONST
  151.     kOCEalanXtn*                    = LONG("alan");
  152.     kOCEentnXtn*                    = LONG("entn");                        (* entn* = entity name (aka DSSpec) *)
  153.     kOCEaphnXtn*                    = LONG("aphn");
  154.  
  155. (*
  156. Following are the specific definitions for the extension for the standard
  157. OCEMail LONG("entn") addresses.  [Note, the actual extension is formatted as in
  158. IPMEntityNameExtension.]
  159. *)
  160. (* entn extension forms *)
  161.     kOCEAddrXtn*                    = LONG("addr");
  162.     kOCEQnamXtn*                    = LONG("qnam");
  163.     kOCEAttrXtn*                    = LONG("attr");                        (* an attribute specification *)
  164.     kOCESpAtXtn*                    = LONG("spat");
  165.  
  166. (*
  167. Following are the specific definitions for standard
  168. OCEMail LONG("aphn") extension value.  
  169.  
  170. All RStrings here are packed (e.g. truncated to length) and even padded (e.g.
  171. if length odd, then a pad byte (zero) should be introduced before the next field).
  172.  
  173. The extension value is in the packed form of the following structure*:
  174.     RString        phoneNumber;
  175.     RString        modemType;
  176.     Types.Str32        queueuName;
  177.  
  178. The body of phoneNumber compound RString is in the packed form of the following structure*:
  179.     short         subType;
  180.     RString     countryCode;                // used when subType == kOCEUseHandyDial
  181.     RString        areaCode;                    // used when subType == kOCEUseHandyDial
  182.     RString        phone;                        // used when subType == kOCEUseHandyDial
  183.     RString        postFix;                    // used when subType == kOCEUseHandyDial
  184.     RString        nonHandyDialString;            // used when subType == kOCEDontUseHandyDial
  185. *)
  186. (* phoneNumber sub type constants *)
  187.     kOCEUseHandyDial*            = 1;
  188.     kOCEDontUseHandyDial*        = 2;
  189.  
  190. (* FORMAT OF A (*ΔΔPACKEDΔΔ*) FORM RECIPIENT *)
  191.  
  192. TYPE
  193.     ProtoOCEPackedRecipient* = RECORD
  194.         dataLength*:                INTEGER;
  195.     END;
  196.  
  197.  
  198. CONST
  199.     kOCEPackedRecipientMaxBytes*    = 4096 - SIZE (*ΔΔ sizeof*)(ProtoOCEPackedRecipient);
  200.  
  201.  
  202. TYPE
  203.     OCEPackedRecipient* = RECORD
  204.         dataLength*:                INTEGER;
  205.         data*:                    ARRAY (*ΔΔ[0..*)kOCEPackedRecipientMaxBytes(*ΔΔ -1]ΔΔ*) OF Types.SInt8; (* Types.Byte *)
  206.     END;
  207.  
  208.     IPMEntnQueueExtension* = RECORD
  209.         queueName*:                Types.Str32;
  210.     END;
  211.  
  212. (* kOCEAttrXtn *)
  213.     IPMEntnAttributeExtension* = RECORD
  214.         attributeName*:            OCE.AttributeType;
  215.     END;
  216.  
  217. (* kOCESpAtXtn *)
  218.     IPMEntnSpecificAttributeExtension* = RECORD
  219.         attributeCreationID*:    OCE.AttributeCreationID;
  220.         attributeName*:            OCE.AttributeType;
  221.     END;
  222.  
  223. (* All IPM entn extensions fit within the following *)
  224.     IPMEntityNameExtension* = RECORD
  225.         subExtensionType*:        Types.OSType;
  226.         (*ΔΔ CASE INTEGER OF
  227.         0: ( *)
  228.     END;
  229.     IPMENESpecificAttribute* = RECORD(IPMEntityNameExtension)
  230.             specificAttribute*:            IPMEntnSpecificAttributeExtension;
  231.            (*ΔΔ );
  232.         1: ( *)
  233.     END;
  234.     IPMENEAttribute* = RECORD(IPMEntityNameExtension)
  235.             attribute*:                    IPMEntnAttributeExtension;
  236.            (*ΔΔ );
  237.         2: ( *)
  238.     END;
  239.     IPMENEQueue* = RECORD(IPMEntityNameExtension)
  240.             queue*:                        IPMEntnQueueExtension;
  241.            (*ΔΔ );*)
  242.     END;
  243.  
  244. (* addresses with kIPMNBPXtn should specify this nbp type *)
  245.     IPMMsgID* = RECORD
  246.         id*:                        ARRAY 4 (*ΔΔ[0..3]ΔΔ*) OF LONGINT;
  247.     END;
  248.  
  249. (* Values of IPMHeaderSelector *)
  250.  
  251. CONST
  252.     kIPMTOC*                        = 0;
  253.     kIPMSender*                    = 1;
  254.     kIPMProcessHint*                = 2;
  255.     kIPMMessageTitle*            = 3;
  256.     kIPMMessageType*                = 4;
  257.     kIPMFixedInfo*                = 7;
  258.  
  259.     
  260. TYPE
  261.     IPMHeaderSelector* = Types.Byte;
  262.  
  263.     TheSender* = RECORD
  264.         (*ΔΔ CASE INTEGER OF
  265.         0: ( *)
  266.     END;
  267.     TheSenderString* = RECORD(TheSender)
  268.             rString*:                    OCE.RString;
  269.            (*ΔΔ );
  270.         1: ( *)
  271.     END;
  272.     TheSenderID* = RECORD(TheSender)
  273.             rid*:                        OCE.PackedRecordID;
  274.            (*ΔΔ );*)
  275.     END;
  276.  
  277.     IPMSender* = RECORD
  278.         sendTag*:                IPMSenderTag;
  279.         theSender*:                TheSender;
  280.     END;
  281.  
  282.     OCERecipient* = OCE.DSSpec;
  283.  
  284. (******************************************************************************)
  285. (* Definitions specific to OCEMessaging *)
  286.     IPMContextRef* = LONGINT;
  287.  
  288.     IPMQueueRef* = LONGINT;
  289.  
  290.     IPMMsgRef* = LONGINT;
  291.  
  292.     IPMSeqNum* = LONGINT;
  293.  
  294.     IPMProcHint* = Types.Str32;
  295.  
  296.     IPMQueueName* = Types.Str32;
  297.  
  298.     IPMNoteProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (queue: IPMQueueRef; seqNum: IPMSeqNum; notificationType: Types.ByteParameter; userData: LONGINT);
  299.     IPMNoteUPP* = Types.UniversalProcPtr;
  300.  
  301. CONST
  302.     uppIPMNoteProcInfo* = $000037C0; (* PROCEDURE (4 byte param, 4 byte param, 1 byte param, 4 byte param); *)
  303.  
  304. PROCEDURE NewIPMNoteProc*(userRoutine: IPMNoteProcPtr): IPMNoteUPP;
  305.     (*$IF NOT GENERATINGCFM *)
  306.     INLINE PASCAL $2E9F;
  307.     (*$END*)
  308.  
  309. PROCEDURE CallIPMNoteProc*(queue: IPMQueueRef; seqNum: IPMSeqNum; notificationType: Types.ByteParameter; userData: LONGINT; userRoutine: IPMNoteUPP);
  310.     (*$IF NOT GENERATINGCFM*)
  311.     INLINE PASCAL $205F, $4E90;
  312.     (*$END*)
  313.  
  314. TYPE
  315.     IPMFixedHdrInfo* = RECORD
  316.         version*:                INTEGER;
  317.         authenticated*:            BOOLEAN;
  318.         signatureEnclosed*:        BOOLEAN;                                (*  digital signature enclosed *)
  319.         msgSize*:                LONGINT;
  320.         notification*:            IPMNotificationType;
  321.         priority*:                IPMPriority;
  322.         blockCount*:                INTEGER;
  323.         originalRcptCount*:        INTEGER;                                (*        original number of recipients *)
  324.         refCon*:                    LONGINT;                                (*        Client defined data *)
  325.         reserved*:                INTEGER;
  326.         creationTime*:            OCE.UTCTime;                                (*        Sound.Time when it was created *)
  327.         msgID*:                    IPMMsgID;
  328.         family*:                    Types.OSType;                                    (* family this msg belongs (e.g. mail) *)
  329.     END;
  330.  
  331.  
  332. CONST
  333.     kIPMDeliveryNotificationBit*    = 0;
  334.     kIPMNonDeliveryNotificationBit* = 1;
  335.     kIPMEncloseOriginalBit*        = 2;
  336.     kIPMSummaryReportBit*        = 3;
  337. (* modify enclose original to only on error *)
  338.     kIPMOriginalOnlyOnErrorBit*    = 4;
  339.  
  340.     kIPMNoNotificationMask*        = $00;
  341.     kIPMDeliveryNotificationMask* = ASH(1,kIPMDeliveryNotificationBit);
  342.     kIPMNonDeliveryNotificationMask* = ASH(1,kIPMNonDeliveryNotificationBit);
  343.     kIPMDontEncloseOriginalMask*    = $00;
  344.     kIPMEncloseOriginalMask*        = ASH(1,kIPMEncloseOriginalBit);
  345.     kIPMImmediateReportMask*        = $00;
  346.     kIPMSummaryReportMask*        = ASH(1,kIPMSummaryReportBit);
  347.     kIPMOriginalOnlyOnErrorMask*    = ASH(1,kIPMOriginalOnlyOnErrorBit);
  348.     kIPMEncloseOriginalOnErrorMask* = kIPMOriginalOnlyOnErrorMask + kIPMEncloseOriginalMask;
  349.  
  350.     kIPMNoSuchRecipient*            = $0001;
  351.     kIPMRecipientMalformed*        = $0002;
  352.     kIPMRecipientAmbiguous*        = $0003;
  353.     kIPMRecipientAccessDenied*    = $0004;
  354.     kIPMGroupExpansionProblem*    = $0005;
  355.     kIPMMsgUnreadable*            = $0006;
  356.     kIPMMsgExpired*                = $0007;
  357.     kIPMMsgNoTranslatableContent* = $0008;
  358.     kIPMRecipientReqStdCont*        = $0009;
  359.     kIPMRecipientReqSnapShot*    = $000A;
  360.     kIPMNoTransferDiskFull*        = $000B;
  361.     kIPMNoTransferMsgRejectedbyDest* = $000C;
  362.     kIPMNoTransferMsgTooLarge*    = $000D;
  363.  
  364. (*************************************************************************)
  365. (*
  366. This is the structure that will be returned by enumerate and getmsginfo
  367. This definition is just to give you a template, the position of msgType
  368. is variable since this is a packed structure.  procHint and msgType are
  369. packed and even length padded.
  370.  
  371. * master message info *)
  372.  
  373. TYPE
  374.     IPMMsgInfo* = RECORD
  375.         sequenceNum*:            IPMSeqNum;
  376.         userData*:                LONGINT;
  377.         respIndex*:                INTEGER;
  378.         padByte*:                Types.SInt8;
  379.         priority*:                IPMPriority;
  380.         msgSize*:                LONGINT;
  381.         originalRcptCount*:        INTEGER;
  382.         reserved*:                INTEGER;
  383.         creationTime*:            OCE.UTCTime;
  384.         msgID*:                    IPMMsgID;
  385.         family*:                    Types.OSType;                                    (* family this msg belongs (e.g. mail) *)
  386.         procHint*:                IPMProcHint;
  387.         filler2*:                Types.SInt8;
  388.         msgType*:                IPMMsgType;
  389.     END;
  390.  
  391.     IPMBlockType* = OCECreatorType;
  392.  
  393.     IPMTOC* = RECORD
  394.         blockType*:                IPMBlockType;
  395.         blockOffset*:            LONGINT;
  396.         blockSize*:                LONGINT;
  397.         blockRefCon*:            LONGINT;
  398.     END;
  399.  
  400. (*
  401. The following structure is just to describe the layout of the SingleFilter.
  402. Each field should be packed and word aligned when passed to the IPM ToolBox.
  403. *)
  404.     IPMSingleFilter* = RECORD
  405.         priority*:                IPMPriority;
  406.         padByte*:                Types.SInt8;
  407.         family*:                    Types.OSType;                                    (* family this msg belongs (e.g. mail), '??POINTER TO  for all *)
  408.         script*:                    Types.ScriptCode;                                (* Language Identifier *)
  409.         hint*:                    IPMProcHint;
  410.         filler2*:                Types.SInt8;
  411.         msgType*:                IPMMsgType;
  412.     END;
  413.  
  414.     IPMFilter* = RECORD
  415.         count*:                    INTEGER;
  416.         sFilters*:                ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF IPMSingleFilter;
  417.     END;
  418.  
  419. (*************************************************************************
  420. Following structures define the “start” of a recipient report block and the
  421. elements of the array respectively.
  422. *)
  423.     IPMReportBlockHeader* = RECORD
  424.         msgID*:                    IPMMsgID;                                (* message id of the original *)
  425.         creationTime*:            OCE.UTCTime;                                (* creation time of the report *)
  426.     END;
  427.  
  428.     OCERecipientReport* = RECORD
  429.         rcptIndex*:                INTEGER;                                (* index of recipient in original message *)
  430.         result*:                    Types.OSErr;                                    (* result of sending letter to this recipient*)
  431.     END;
  432.  
  433. (*************************************************************************)
  434.     IPMParamBlockPtr* = POINTER TO IPMParamBlock;
  435.  
  436.     IPMIOCompletionProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (paramBlock: IPMParamBlockPtr);
  437.     IPMIOCompletionUPP* = Types.UniversalProcPtr;
  438.  
  439.     IPMOpenContextPB* = RECORD
  440.         qLink*:                    Types.Ptr;
  441.         reservedH1*:                LONGINT;
  442.         reservedH2*:                LONGINT;
  443.         ioCompletion*:            IPMIOCompletionUPP;
  444.         ioResult*:                Types.OSErr;
  445.         saveA5*:                    LONGINT;
  446.         reqCode*:                INTEGER;
  447.         contextRef*:                IPMContextRef;                            (* <--  Context reference to be used in further calls*)
  448.     END;
  449.  
  450.     IPMCloseContextPB* = IPMOpenContextPB;
  451.  
  452.     IPMCreateQueuePB* = RECORD
  453.         qLink*:                    Types.Ptr;
  454.         reservedH1*:                LONGINT;
  455.         reservedH2*:                LONGINT;
  456.         ioCompletion*:            IPMIOCompletionUPP;
  457.         ioResult*:                Types.OSErr;
  458.         saveA5*:                    LONGINT;
  459.         reqCode*:                INTEGER;
  460.         filler1*:                LONGINT;
  461.         queue*:                    POINTER TO OCERecipient;
  462.         identity*:                OCEAuthDir.AuthIdentity;                            (* used only if queue is remote *)
  463.         owner*:                    POINTER TO OCE.PackedRecordID;                        (* used only if queue is remote *)
  464.     END;
  465.  
  466. (* For createqueue and deletequeue only queue and identity are used *)
  467.     IPMDeleteQueuePB* = IPMCreateQueuePB;
  468.  
  469.     IPMOpenQueuePB* = RECORD
  470.         qLink*:                    Types.Ptr;
  471.         reservedH1*:                LONGINT;
  472.         reservedH2*:                LONGINT;
  473.         ioCompletion*:            IPMIOCompletionUPP;
  474.         ioResult*:                Types.OSErr;
  475.         saveA5*:                    LONGINT;
  476.         reqCode*:                INTEGER;
  477.         contextRef*:                IPMContextRef;
  478.         queue*:                    POINTER TO OCERecipient;
  479.         identity*:                OCEAuthDir.AuthIdentity;
  480.         filter*:                    POINTER TO IPMFilter;
  481.         newQueueRef*:            IPMQueueRef;
  482.         notificationProc*:        IPMNoteUPP;
  483.         userData*:                LONGINT;
  484.         noteType*:                IPMNotificationType;
  485.         padByte*:                Types.SInt8; (* Types.Byte *)
  486.         reserved*:                LONGINT;
  487.         reserved2*:                LONGINT;
  488.     END;
  489.  
  490.     IPMCloseQueuePB* = RECORD
  491.         qLink*:                    Types.Ptr;
  492.         reservedH1*:                LONGINT;
  493.         reservedH2*:                LONGINT;
  494.         ioCompletion*:            IPMIOCompletionUPP;
  495.         ioResult*:                Types.OSErr;
  496.         saveA5*:                    LONGINT;
  497.         reqCode*:                INTEGER;
  498.         queueRef*:                IPMQueueRef;
  499.     END;
  500.  
  501.     IPMEnumerateQueuePB* = RECORD
  502.         qLink*:                    Types.Ptr;
  503.         reservedH1*:                LONGINT;
  504.         reservedH2*:                LONGINT;
  505.         ioCompletion*:            IPMIOCompletionUPP;
  506.         ioResult*:                Types.OSErr;
  507.         saveA5*:                    LONGINT;
  508.         reqCode*:                INTEGER;
  509.         queueRef*:                IPMQueueRef;
  510.         startSeqNum*:            IPMSeqNum;
  511.         getProcHint*:            BOOLEAN;
  512.         getMsgType*:                BOOLEAN;
  513.         filler*:                    INTEGER;
  514.         filter*:                    POINTER TO IPMFilter;
  515.         numToGet*:                INTEGER;
  516.         numGotten*:                INTEGER;
  517.         enumCount*:                LONGINT;
  518.         enumBuffer*:                Types.Ptr;                                    (* will be packed array of IPMMsgInfo *)
  519.         actEnumCount*:            LONGINT;
  520.     END;
  521.  
  522.     IPMChangeQueueFilterPB* = IPMEnumerateQueuePB;
  523.  
  524.     IPMDeleteMsgRangePB* = RECORD
  525.         qLink*:                    Types.Ptr;
  526.         reservedH1*:                LONGINT;
  527.         reservedH2*:                LONGINT;
  528.         ioCompletion*:            IPMIOCompletionUPP;
  529.         ioResult*:                Types.OSErr;
  530.         saveA5*:                    LONGINT;
  531.         reqCode*:                INTEGER;
  532.         queueRef*:                IPMQueueRef;
  533.         startSeqNum*:            IPMSeqNum;
  534.         endSeqNum*:                IPMSeqNum;
  535.         lastSeqNum*:                IPMSeqNum;
  536.     END;
  537.  
  538.     IPMOpenMsgPB* = RECORD
  539.         qLink*:                    Types.Ptr;
  540.         reservedH1*:                LONGINT;
  541.         reservedH2*:                LONGINT;
  542.         ioCompletion*:            IPMIOCompletionUPP;
  543.         ioResult*:                Types.OSErr;
  544.         saveA5*:                    LONGINT;
  545.         reqCode*:                INTEGER;
  546.         queueRef*:                IPMQueueRef;
  547.         sequenceNum*:            IPMSeqNum;
  548.         newMsgRef*:                IPMMsgRef;
  549.         actualSeqNum*:            IPMSeqNum;
  550.         exactMatch*:                BOOLEAN;
  551.         padByte*:                Types.SInt8; (* Types.Byte *)
  552.         reserved*:                LONGINT;
  553.     END;
  554.  
  555.     IPMOpenHFSMsgPB* = RECORD
  556.         qLink*:                    Types.Ptr;
  557.         reservedH1*:                LONGINT;
  558.         reservedH2*:                LONGINT;
  559.         ioCompletion*:            IPMIOCompletionUPP;
  560.         ioResult*:                Types.OSErr;
  561.         saveA5*:                    LONGINT;
  562.         reqCode*:                INTEGER;
  563.         hfsPath*:                POINTER TO Files.FSSpec;
  564.         filler*:                    LONGINT;
  565.         newMsgRef*:                IPMMsgRef;
  566.         filler2*:                LONGINT;
  567.         filler3*:                Types.SInt8; (* Types.Byte *)
  568.         filler4*:                BOOLEAN;
  569.         reserved*:                LONGINT;
  570.     END;
  571.  
  572.     IPMOpenBlockAsMsgPB* = RECORD
  573.         qLink*:                    Types.Ptr;
  574.         reservedH1*:                LONGINT;
  575.         reservedH2*:                LONGINT;
  576.         ioCompletion*:            IPMIOCompletionUPP;
  577.         ioResult*:                Types.OSErr;
  578.         saveA5*:                    LONGINT;
  579.         reqCode*:                INTEGER;
  580.         msgRef*:                    IPMMsgRef;
  581.         filler*:                    LONGINT;
  582.         newMsgRef*:                IPMMsgRef;
  583.         filler2*:                ARRAY 7 (*ΔΔ[0..6]ΔΔ*) OF INTEGER;
  584.         blockIndex*:                INTEGER;
  585.     END;
  586.  
  587.     IPMCloseMsgPB* = RECORD
  588.         qLink*:                    Types.Ptr;
  589.         reservedH1*:                LONGINT;
  590.         reservedH2*:                LONGINT;
  591.         ioCompletion*:            IPMIOCompletionUPP;
  592.         ioResult*:                Types.OSErr;
  593.         saveA5*:                    LONGINT;
  594.         reqCode*:                INTEGER;
  595.         msgRef*:                    IPMMsgRef;
  596.         deleteMsg*:                BOOLEAN;
  597.         filler1*:                BOOLEAN;
  598.     END;
  599.  
  600.     IPMGetMsgInfoPB* = RECORD
  601.         qLink*:                    Types.Ptr;
  602.         reservedH1*:                LONGINT;
  603.         reservedH2*:                LONGINT;
  604.         ioCompletion*:            IPMIOCompletionUPP;
  605.         ioResult*:                Types.OSErr;
  606.         saveA5*:                    LONGINT;
  607.         reqCode*:                INTEGER;
  608.         msgRef*:                    IPMMsgRef;
  609.         info*:                    POINTER TO IPMMsgInfo;
  610.     END;
  611.  
  612.     IPMReadHeaderPB* = RECORD
  613.         qLink*:                    Types.Ptr;
  614.         reservedH1*:                LONGINT;
  615.         reservedH2*:                LONGINT;
  616.         ioCompletion*:            IPMIOCompletionUPP;
  617.         ioResult*:                Types.OSErr;
  618.         saveA5*:                    LONGINT;
  619.         reqCode*:                INTEGER;
  620.         msgRef*:                    IPMMsgRef;
  621.         fieldSelector*:            INTEGER;
  622.         offset*:                    LONGINT;
  623.         count*:                    LONGINT;
  624.         buffer*:                    Types.Ptr;
  625.         actualCount*:            LONGINT;
  626.         filler*:                    INTEGER;
  627.         remaining*:                LONGINT;
  628.     END;
  629.  
  630.     IPMReadRecipientPB* = RECORD
  631.         qLink*:                    Types.Ptr;
  632.         reservedH1*:                LONGINT;
  633.         reservedH2*:                LONGINT;
  634.         ioCompletion*:            IPMIOCompletionUPP;
  635.         ioResult*:                Types.OSErr;
  636.         saveA5*:                    LONGINT;
  637.         reqCode*:                INTEGER;
  638.         msgRef*:                    IPMMsgRef;
  639.         rcptIndex*:                INTEGER;
  640.         offset*:                    LONGINT;
  641.         count*:                    LONGINT;
  642.         buffer*:                    Types.Ptr;
  643.         actualCount*:            LONGINT;
  644.         reserved*:                INTEGER;                                (* must be zero *)
  645.         remaining*:                LONGINT;
  646.         originalIndex*:            INTEGER;
  647.         recipientOffsetFlags*:    OCERecipientOffsetFlags;
  648.         filler1*:                BOOLEAN;
  649.     END;
  650.  
  651. (*
  652. replyQueue works like recipient. [can no longer read it via ReadHeader]
  653. OriginalIndex is meaningless, rcptFlags are used seperately and there are
  654. currently none defined.
  655. *)
  656.     IPMReadReplyQueuePB* = IPMReadRecipientPB;
  657.  
  658.     IPMGetBlkIndexPB* = RECORD
  659.         qLink*:                    Types.Ptr;
  660.         reservedH1*:                LONGINT;
  661.         reservedH2*:                LONGINT;
  662.         ioCompletion*:            IPMIOCompletionUPP;
  663.         ioResult*:                Types.OSErr;
  664.         saveA5*:                    LONGINT;
  665.         reqCode*:                INTEGER;
  666.         msgRef*:                    IPMMsgRef;
  667.         blockType*:                IPMBlockType;
  668.         index*:                    INTEGER;
  669.         startingFrom*:            INTEGER;
  670.         actualBlockType*:        IPMBlockType;
  671.         actualBlockIndex*:        INTEGER;
  672.     END;
  673.  
  674.     IPMReadMsgPB* = RECORD
  675.         qLink*:                    Types.Ptr;
  676.         reservedH1*:                LONGINT;
  677.         reservedH2*:                LONGINT;
  678.         ioCompletion*:            IPMIOCompletionUPP;
  679.         ioResult*:                Types.OSErr;
  680.         saveA5*:                    LONGINT;
  681.         reqCode*:                INTEGER;
  682.         msgRef*:                    IPMMsgRef;
  683.         mode*:                    IPMAccessMode;
  684.         offset*:                    LONGINT;
  685.         count*:                    LONGINT;
  686.         buffer*:                    Types.Ptr;
  687.         actualCount*:            LONGINT;
  688.         blockIndex*:                INTEGER;
  689.         remaining*:                LONGINT;
  690.     END;
  691.  
  692.     IPMVerifySignaturePB* = RECORD
  693.         qLink*:                    Types.Ptr;
  694.         reservedH1*:                LONGINT;
  695.         reservedH2*:                LONGINT;
  696.         ioCompletion*:            IPMIOCompletionUPP;
  697.         ioResult*:                Types.OSErr;
  698.         saveA5*:                    LONGINT;
  699.         reqCode*:                INTEGER;
  700.         msgRef*:                    IPMMsgRef;
  701.         signatureContext*:        DigitalSignature.SIGContextPtr;
  702.     END;
  703.  
  704.     IPMNewMsgPB* = RECORD
  705.         qLink*:                    Types.Ptr;
  706.         reservedH1*:                LONGINT;
  707.         reservedH2*:                LONGINT;
  708.         ioCompletion*:            IPMIOCompletionUPP;
  709.         ioResult*:                Types.OSErr;
  710.         saveA5*:                    LONGINT;
  711.         reqCode*:                INTEGER;
  712.         filler*:                    LONGINT;
  713.         recipient*:                POINTER TO OCERecipient;
  714.         replyQueue*:                POINTER TO OCERecipient;
  715.         procHint*:                Types.StringPtr;
  716.         filler2*:                INTEGER;
  717.         msgType*:                POINTER TO IPMMsgType;
  718.         refCon*:                    LONGINT;
  719.         newMsgRef*:                IPMMsgRef;
  720.         filler3*:                INTEGER;
  721.         filler4*:                LONGINT;
  722.         identity*:                OCEAuthDir.AuthIdentity;
  723.         sender*:                    POINTER TO IPMSender;
  724.         internalUse*:            LONGINT;
  725.         internalUse2*:            LONGINT;
  726.     END;
  727.  
  728.     IPMNewHFSMsgPB* = RECORD
  729.         qLink*:                    Types.Ptr;
  730.         reservedH1*:                LONGINT;
  731.         reservedH2*:                LONGINT;
  732.         ioCompletion*:            IPMIOCompletionUPP;
  733.         ioResult*:                Types.OSErr;
  734.         saveA5*:                    LONGINT;
  735.         reqCode*:                INTEGER;
  736.         hfsPath*:                POINTER TO Files.FSSpec;
  737.         recipient*:                POINTER TO OCERecipient;
  738.         replyQueue*:                POINTER TO OCERecipient;
  739.         procHint*:                Types.StringPtr;
  740.         filler2*:                INTEGER;
  741.         msgType*:                POINTER TO IPMMsgType;
  742.         refCon*:                    LONGINT;
  743.         newMsgRef*:                IPMMsgRef;
  744.         filler3*:                INTEGER;
  745.         filler4*:                LONGINT;
  746.         identity*:                OCEAuthDir.AuthIdentity;
  747.         sender*:                    POINTER TO IPMSender;
  748.         internalUse*:            LONGINT;
  749.         internalUse2*:            LONGINT;
  750.     END;
  751.  
  752.     IPMNestMsgPB* = RECORD
  753.         qLink*:                    Types.Ptr;
  754.         reservedH1*:                LONGINT;
  755.         reservedH2*:                LONGINT;
  756.         ioCompletion*:            IPMIOCompletionUPP;
  757.         ioResult*:                Types.OSErr;
  758.         saveA5*:                    LONGINT;
  759.         reqCode*:                INTEGER;
  760.         msgRef*:                    IPMMsgRef;
  761.         filler*:                    ARRAY 9 (*ΔΔ[0..8]ΔΔ*) OF INTEGER;
  762.         refCon*:                    LONGINT;
  763.         msgToNest*:                IPMMsgRef;
  764.         filler2*:                INTEGER;
  765.         startingOffset*:            LONGINT;
  766.     END;
  767.  
  768.     IPMNewNestedMsgBlockPB* = RECORD
  769.         qLink*:                    Types.Ptr;
  770.         reservedH1*:                LONGINT;
  771.         reservedH2*:                LONGINT;
  772.         ioCompletion*:            IPMIOCompletionUPP;
  773.         ioResult*:                Types.OSErr;
  774.         saveA5*:                    LONGINT;
  775.         reqCode*:                INTEGER;
  776.         msgRef*:                    IPMMsgRef;
  777.         recipient*:                POINTER TO OCERecipient;
  778.         replyQueue*:                POINTER TO OCERecipient;
  779.         procHint*:                Types.StringPtr;
  780.         filler1*:                INTEGER;
  781.         msgType*:                POINTER TO IPMMsgType;
  782.         refCon*:                    LONGINT;
  783.         newMsgRef*:                IPMMsgRef;
  784.         filler2*:                INTEGER;
  785.         startingOffset*:            LONGINT;
  786.         identity*:                OCEAuthDir.AuthIdentity;
  787.         sender*:                    POINTER TO IPMSender;
  788.         internalUse*:            LONGINT;
  789.         internalUse2*:            LONGINT;
  790.     END;
  791.  
  792.     IPMEndMsgPB* = RECORD
  793.         qLink*:                    Types.Ptr;
  794.         reservedH1*:                LONGINT;
  795.         reservedH2*:                LONGINT;
  796.         ioCompletion*:            IPMIOCompletionUPP;
  797.         ioResult*:                Types.OSErr;
  798.         saveA5*:                    LONGINT;
  799.         reqCode*:                INTEGER;
  800.         msgRef*:                    IPMMsgRef;
  801.         msgID*:                    IPMMsgID;
  802.         msgTitle*:                POINTER TO OCE.RString;
  803.         deliveryNotification*:    IPMNotificationType;
  804.         priority*:                IPMPriority;
  805.         cancel*:                    BOOLEAN;
  806.         padByte*:                Types.SInt8; (* Types.Byte *)
  807.         reserved*:                LONGINT;
  808.         signature*:                DigitalSignature.SIGSignaturePtr;
  809.         signatureSize*:            Memory.Size;
  810.         signatureContext*:        DigitalSignature.SIGContextPtr;
  811.         (* family this msg belongs (e.g. mail) use kIPMFamilyUnspecified by default *)
  812.         family*:                    Types.OSType;
  813.     END;
  814.  
  815.     IPMAddRecipientPB* = RECORD
  816.         qLink*:                    Types.Ptr;
  817.         reservedH1*:                LONGINT;
  818.         reservedH2*:                LONGINT;
  819.         ioCompletion*:            IPMIOCompletionUPP;
  820.         ioResult*:                Types.OSErr;
  821.         saveA5*:                    LONGINT;
  822.         reqCode*:                INTEGER;
  823.         msgRef*:                    IPMMsgRef;
  824.         recipient*:                POINTER TO OCERecipient;
  825.         reserved*:                LONGINT;
  826.     END;
  827.  
  828.     IPMAddReplyQueuePB* = RECORD
  829.         qLink*:                    Types.Ptr;
  830.         reservedH1*:                LONGINT;
  831.         reservedH2*:                LONGINT;
  832.         ioCompletion*:            IPMIOCompletionUPP;
  833.         ioResult*:                Types.OSErr;
  834.         saveA5*:                    LONGINT;
  835.         reqCode*:                INTEGER;
  836.         msgRef*:                    IPMMsgRef;
  837.         filler*:                    LONGINT;
  838.         replyQueue*:                POINTER TO OCERecipient;
  839.     END;
  840.  
  841.     IPMNewBlockPB* = RECORD
  842.         qLink*:                    Types.Ptr;
  843.         reservedH1*:                LONGINT;
  844.         reservedH2*:                LONGINT;
  845.         ioCompletion*:            IPMIOCompletionUPP;
  846.         ioResult*:                Types.OSErr;
  847.         saveA5*:                    LONGINT;
  848.         reqCode*:                INTEGER;
  849.         msgRef*:                    IPMMsgRef;
  850.         blockType*:                IPMBlockType;
  851.         filler*:                    ARRAY 5 (*ΔΔ[0..4]ΔΔ*) OF INTEGER;
  852.         refCon*:                    LONGINT;
  853.         filler2*:                ARRAY 3 (*ΔΔ[0..2]ΔΔ*) OF INTEGER;
  854.         startingOffset*:            LONGINT;
  855.     END;
  856.  
  857.     IPMWriteMsgPB* = RECORD
  858.         qLink*:                    Types.Ptr;
  859.         reservedH1*:                LONGINT;
  860.         reservedH2*:                LONGINT;
  861.         ioCompletion*:            IPMIOCompletionUPP;
  862.         ioResult*:                Types.OSErr;
  863.         saveA5*:                    LONGINT;
  864.         reqCode*:                INTEGER;
  865.         msgRef*:                    IPMMsgRef;
  866.         mode*:                    IPMAccessMode;
  867.         offset*:                    LONGINT;
  868.         count*:                    LONGINT;
  869.         buffer*:                    Types.Ptr;
  870.         actualCount*:            LONGINT;
  871.         currentBlock*:            BOOLEAN;
  872.         filler1*:                BOOLEAN;
  873.     END;
  874.  
  875.     IPMParamBlock* = RECORD
  876.         (*ΔΔ CASE INTEGER OF
  877.         0: ( *)
  878.             qLink*:                        Types.Ptr;
  879.             reservedH1*:                    LONGINT;
  880.             reservedH2*:                    LONGINT;
  881.             ioCompletion*:                IPMIOCompletionUPP;
  882.             ioResult*:                    Types.OSErr;
  883.             saveA5*:                        LONGINT;
  884.             reqCode*:                    INTEGER;
  885.            (*ΔΔ );
  886.         1: (
  887.             openContextPB*:                IPMOpenContextPB;
  888.            );
  889.         2: (
  890.             closeContextPB*:                IPMCloseContextPB;
  891.            );
  892.         3: (
  893.             createQueuePB*:                IPMCreateQueuePB;
  894.            );
  895.         4: (
  896.             deleteQueuePB*:                IPMDeleteQueuePB;
  897.            );
  898.         5: (
  899.             openQueuePB*:                IPMOpenQueuePB;
  900.            );
  901.         6: (
  902.             closeQueuePB*:                IPMCloseQueuePB;
  903.            );
  904.         7: (
  905.             enumerateQueuePB*:            IPMEnumerateQueuePB;
  906.            );
  907.         8: (
  908.             changeQueueFilterPB*:        IPMChangeQueueFilterPB;
  909.            );
  910.         9: (
  911.             deleteMsgRangePB*:            IPMDeleteMsgRangePB;
  912.            );
  913.         10: (
  914.             openMsgPB*:                    IPMOpenMsgPB;
  915.            );
  916.         11: (
  917.             openHFSMsgPB*:                IPMOpenHFSMsgPB;
  918.            );
  919.         12: (
  920.             openBlockAsMsgPB*:            IPMOpenBlockAsMsgPB;
  921.            );
  922.         13: (
  923.             closeMsgPB*:                    IPMCloseMsgPB;
  924.            );
  925.         14: (
  926.             getMsgInfoPB*:                IPMGetMsgInfoPB;
  927.            );
  928.         15: (
  929.             readHeaderPB*:                IPMReadHeaderPB;
  930.            );
  931.         16: (
  932.             readRecipientPB*:            IPMReadRecipientPB;
  933.            );
  934.         17: (
  935.             readReplyQueuePB*:            IPMReadReplyQueuePB;
  936.            );
  937.         18: (
  938.             getBlkIndexPB*:                IPMGetBlkIndexPB;
  939.            );
  940.         19: (
  941.             readMsgPB*:                    IPMReadMsgPB;
  942.            );
  943.         20: (
  944.             verifySignaturePB*:            IPMVerifySignaturePB;
  945.            );
  946.         21: (
  947.             newMsgPB*:                    IPMNewMsgPB;
  948.            );
  949.         22: (
  950.             newHFSMsgPB*:                IPMNewHFSMsgPB;
  951.            );
  952.         23: (
  953.             nestMsgPB*:                    IPMNestMsgPB;
  954.            );
  955.         24: (
  956.             newNestedMsgBlockPB*:        IPMNewNestedMsgBlockPB;
  957.            );
  958.         25: (
  959.             endMsgPB*:                    IPMEndMsgPB;
  960.            );
  961.         26: (
  962.             addRecipientPB*:                IPMAddRecipientPB;
  963.            );
  964.         27: (
  965.             addReplyQueuePB*:            IPMAddReplyQueuePB;
  966.            );
  967.         28: (
  968.             newBlockPB*:                    IPMNewBlockPB;
  969.            );
  970.         29: (
  971.             writeMsgPB*:                    IPMWriteMsgPB;
  972.            );*)
  973.     END;
  974.  
  975. (*    Request codes *)
  976.  
  977. CONST
  978.     kIPMOpenContext*                = $400;
  979.     kIPMCloseContext*            = $401;
  980.     kIPMNewMsg*                    = $402;
  981.     kIPMAddRecipient*            = $403;
  982.     kIPMNewBlock*                = $404;
  983.     kIPMNewNestedMsgBlock*        = $405;
  984.     kIPMNestMsg*                    = $406;
  985.     kIPMWriteMsg*                = $407;
  986.     kIPMEndMsg*                    = $408;
  987.     kIPMOpenQueue*                = $409;
  988.     kIPMCloseQueue*                = $40A;
  989.     kIPMOpenMsg*                    = $40B;
  990.     kIPMCloseMsg*                = $40C;
  991.     kIPMReadMsg*                    = $40D;
  992.     kIPMReadHeader*                = $40E;
  993.     kIPMOpenBlockAsMsg*            = $40F;
  994.     kIPMReadRecipient*            = $410;
  995.     kIPMCreateQueue*                = $411;
  996.     kIPMDeleteQueue*                = $412;
  997.     kIPMEnumerateQueue*            = $413;
  998.     kIPMChangeQueueFilter*        = $414;
  999.     kIPMDeleteMsgRange*            = $415;
  1000.     kIPMOpenHFSMsg*                = $417;
  1001.     kIPMGetBlkIndex*                = $418;
  1002.     kIPMGetMsgInfo*                = $419;
  1003.     kIPMAddReplyQueue*            = $41D;
  1004.     kIPMNewHFSMsg*                = $41E;
  1005.     kIPMReadReplyQueue*            = $421;
  1006.     kIPMVerifySignature*            = $422;
  1007.  
  1008.     uppIPMIOCompletionProcInfo* = $000000C0; (* PROCEDURE (4 byte param); *)
  1009.  
  1010. PROCEDURE CallIPMIOCompletionProc*(paramBlock: IPMParamBlockPtr; userRoutine: IPMIOCompletionUPP);
  1011.     (*$IF NOT GENERATINGCFM*)
  1012.     INLINE PASCAL $205F, $4E90;
  1013.     (*$END*)
  1014.  
  1015. PROCEDURE NewIPMIOCompletionProc*(userRoutine: IPMIOCompletionProcPtr): IPMIOCompletionUPP;
  1016.     (*$IF NOT GENERATINGCFM *)
  1017.     INLINE PASCAL $2E9F;
  1018.     (*$END*)
  1019.  
  1020. PROCEDURE IPMOpenContext*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1021.     (*$IF NOT GENERATINGCFM*)
  1022.     INLINE PASCAL $3F3C, $400, $AA5E;
  1023.     (*$END*)
  1024. PROCEDURE IPMCloseContext*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1025.     (*$IF NOT GENERATINGCFM*)
  1026.     INLINE PASCAL $3F3C, $401, $AA5E;
  1027.     (*$END*)
  1028. PROCEDURE IPMNewMsg*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1029.     (*$IF NOT GENERATINGCFM*)
  1030.     INLINE PASCAL $3F3C, $402, $AA5E;
  1031.     (*$END*)
  1032. PROCEDURE IPMNewBlock*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1033.     (*$IF NOT GENERATINGCFM*)
  1034.     INLINE PASCAL $3F3C, $404, $AA5E;
  1035.     (*$END*)
  1036. PROCEDURE IPMNewNestedMsgBlock*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1037.     (*$IF NOT GENERATINGCFM*)
  1038.     INLINE PASCAL $3F3C, $405, $AA5E;
  1039.     (*$END*)
  1040. PROCEDURE IPMNestMsg*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1041.     (*$IF NOT GENERATINGCFM*)
  1042.     INLINE PASCAL $3F3C, $406, $AA5E;
  1043.     (*$END*)
  1044. PROCEDURE IPMWriteMsg*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1045.     (*$IF NOT GENERATINGCFM*)
  1046.     INLINE PASCAL $3F3C, $407, $AA5E;
  1047.     (*$END*)
  1048. PROCEDURE IPMEndMsg*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1049.     (*$IF NOT GENERATINGCFM*)
  1050.     INLINE PASCAL $3F3C, $408, $AA5E;
  1051.     (*$END*)
  1052. PROCEDURE IPMOpenQueue*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1053.     (*$IF NOT GENERATINGCFM*)
  1054.     INLINE PASCAL $3F3C, $409, $AA5E;
  1055.     (*$END*)
  1056. PROCEDURE IPMCloseQueue*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1057.     (*$IF NOT GENERATINGCFM*)
  1058.     INLINE PASCAL $3F3C, $40A, $AA5E;
  1059.     (*$END*)
  1060. (* Always synchronous *)
  1061. PROCEDURE IPMVerifySignature*(paramBlock: IPMParamBlockPtr): Types.OSErr;
  1062.     (*$IF NOT GENERATINGCFM*)
  1063.     INLINE PASCAL $7000, $1f00, $3F3C, $422, $AA5E;
  1064.     (*$END*)
  1065. PROCEDURE IPMOpenMsg*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1066.     (*$IF NOT GENERATINGCFM*)
  1067.     INLINE PASCAL $3F3C, $40B, $AA5E;
  1068.     (*$END*)
  1069. PROCEDURE IPMCloseMsg*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1070.     (*$IF NOT GENERATINGCFM*)
  1071.     INLINE PASCAL $3F3C, $40C, $AA5E;
  1072.     (*$END*)
  1073. PROCEDURE IPMReadMsg*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1074.     (*$IF NOT GENERATINGCFM*)
  1075.     INLINE PASCAL $3F3C, $40D, $AA5E;
  1076.     (*$END*)
  1077. PROCEDURE IPMReadHeader*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1078.     (*$IF NOT GENERATINGCFM*)
  1079.     INLINE PASCAL $3F3C, $40E, $AA5E;
  1080.     (*$END*)
  1081. PROCEDURE IPMOpenBlockAsMsg*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1082.     (*$IF NOT GENERATINGCFM*)
  1083.     INLINE PASCAL $3F3C, $40F, $AA5E;
  1084.     (*$END*)
  1085. PROCEDURE IPMNewHFSMsg*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1086.     (*$IF NOT GENERATINGCFM*)
  1087.     INLINE PASCAL $3F3C, $41E, $AA5E;
  1088.     (*$END*)
  1089. PROCEDURE IPMReadRecipient*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1090.     (*$IF NOT GENERATINGCFM*)
  1091.     INLINE PASCAL $3F3C, $410, $AA5E;
  1092.     (*$END*)
  1093. PROCEDURE IPMReadReplyQueue*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1094.     (*$IF NOT GENERATINGCFM*)
  1095.     INLINE PASCAL $3F3C, $421, $AA5E;
  1096.     (*$END*)
  1097. PROCEDURE IPMCreateQueue*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1098.     (*$IF NOT GENERATINGCFM*)
  1099.     INLINE PASCAL $3F3C, $411, $AA5E;
  1100.     (*$END*)
  1101. PROCEDURE IPMDeleteQueue*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1102.     (*$IF NOT GENERATINGCFM*)
  1103.     INLINE PASCAL $3F3C, $412, $AA5E;
  1104.     (*$END*)
  1105. PROCEDURE IPMEnumerateQueue*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1106.     (*$IF NOT GENERATINGCFM*)
  1107.     INLINE PASCAL $3F3C, $413, $AA5E;
  1108.     (*$END*)
  1109. PROCEDURE IPMChangeQueueFilter*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1110.     (*$IF NOT GENERATINGCFM*)
  1111.     INLINE PASCAL $3F3C, $414, $AA5E;
  1112.     (*$END*)
  1113. PROCEDURE IPMDeleteMsgRange*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1114.     (*$IF NOT GENERATINGCFM*)
  1115.     INLINE PASCAL $3F3C, $415, $AA5E;
  1116.     (*$END*)
  1117. PROCEDURE IPMAddRecipient*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1118.     (*$IF NOT GENERATINGCFM*)
  1119.     INLINE PASCAL $3F3C, $403, $AA5E;
  1120.     (*$END*)
  1121. PROCEDURE IPMAddReplyQueue*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1122.     (*$IF NOT GENERATINGCFM*)
  1123.     INLINE PASCAL $3F3C, $41D, $AA5E;
  1124.     (*$END*)
  1125. PROCEDURE IPMOpenHFSMsg*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1126.     (*$IF NOT GENERATINGCFM*)
  1127.     INLINE PASCAL $3F3C, $417, $AA5E;
  1128.     (*$END*)
  1129. PROCEDURE IPMGetBlkIndex*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1130.     (*$IF NOT GENERATINGCFM*)
  1131.     INLINE PASCAL $3F3C, $418, $AA5E;
  1132.     (*$END*)
  1133. PROCEDURE IPMGetMsgInfo*(paramBlock: IPMParamBlockPtr; async: BOOLEAN): Types.OSErr;
  1134.     (*$IF NOT GENERATINGCFM*)
  1135.     INLINE PASCAL $3F3C, $419, $AA5E;
  1136.     (*$END*)
  1137. (****************************************************************************************)
  1138. (* EXTERNAL ROUTINES *)
  1139.  
  1140. CONST
  1141.     kOCESizePackedRecipient*        = 830;
  1142.     kOCEPackRecipient*            = 831;
  1143.     kOCEUnpackRecipient*            = 832;
  1144.     kOCEStreamRecipient*            = 833;
  1145.     kOCEGetRecipientType*        = 834;
  1146.     kOCESetRecipientType*        = 835;
  1147.  
  1148.  
  1149. PROCEDURE OCESizePackedRecipient*((*CONST*)VAR rcpt: OCERecipient): INTEGER;
  1150.     (*$IF NOT GENERATINGCFM*)
  1151.     INLINE PASCAL $303C, 830, $AA5C;
  1152.     (*$END*)
  1153. (*
  1154. Take an OCERecipient (scatter) and (gather) stream into the specified
  1155. buffer.  It is assumed that there is sufficient space in the buffer (that is
  1156. OCESizePackedRecipient).  Safe to pass dereferenced handle(s).
  1157. *)
  1158. PROCEDURE OCEPackRecipient*((*CONST*)VAR rcpt: OCERecipient; buffer: (*ΔΔUNIVΔΔ*) Types.Ptr): INTEGER;
  1159.     (*$IF NOT GENERATINGCFM*)
  1160.     INLINE PASCAL $303C, 831, $AA5C;
  1161.     (*$END*)
  1162. (*
  1163. Take a packed OCERecipient and cast a the OCERecipient frame over it. Returns
  1164. amBadDestId if it doesn't look like an OCERecipient. Safe to pass dereferenced
  1165. handle(s).
  1166. *)
  1167. PROCEDURE OCEUnpackRecipient*(buffer: (*ΔΔUNIVΔΔ*) Types.Ptr; VAR rcpt: OCERecipient; VAR entitySpecifier: OCE.RecordID): Types.OSErr;
  1168.     (*$IF NOT GENERATINGCFM*)
  1169.     INLINE PASCAL $303C, 832, $AA5C;
  1170.     (*$END*)
  1171. (*
  1172. Take an OCERecipient (scatter) and (gather) stream using the specified
  1173. function.  Safe to pass dereferenced handle(s).  If streamer function returns
  1174. OCEError OCEStreamRecipient stops execution and passes the error back to the caller
  1175. *)
  1176. TYPE
  1177.     OCERecipientStreamerProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (buffer: (*ΔΔUNIVΔΔ*) Types.Ptr; count: LONGINT; eof: BOOLEAN; userData: LONGINT): Types.OSErr;
  1178.     OCERecipientStreamerUPP* = Types.UniversalProcPtr;
  1179.  
  1180. CONST
  1181.     uppOCERecipientStreamerProcInfo* = $000037E0; (* PROCEDURE (4 byte param, 4 byte param, 1 byte param, 4 byte param): 2 byte result; *)
  1182.  
  1183. PROCEDURE NewOCERecipientStreamerProc*(userRoutine: OCERecipientStreamerProcPtr): OCERecipientStreamerUPP;
  1184.     (*$IF NOT GENERATINGCFM *)
  1185.     INLINE PASCAL $2E9F;
  1186.     (*$END*)
  1187.  
  1188. PROCEDURE CallOCERecipientStreamerProc*(buffer: (*ΔΔUNIVΔΔ*) Types.Ptr; count: LONGINT; eof: BOOLEAN; userData: LONGINT; userRoutine: OCERecipientStreamerUPP): Types.OSErr;
  1189.     (*$IF NOT GENERATINGCFM*)
  1190.     INLINE PASCAL $205F, $4E90;
  1191.     (*$END*)
  1192.     
  1193. TYPE
  1194.     OCERecipientStreamer* = OCERecipientStreamerUPP;
  1195.  
  1196.  
  1197. PROCEDURE OCEStreamRecipient*((*CONST*)VAR rcpt: OCERecipient; stream: OCERecipientStreamer; userData: LONGINT; VAR actualCount: LONGINT): Types.OSErr;
  1198.     (*$IF NOT GENERATINGCFM*)
  1199.     INLINE PASCAL $303C, 833, $AA5C;
  1200.     (*$END*)
  1201. (* Get the OCERecipient's extensionType. Safe to pass dereferenced handle(s).*)
  1202. PROCEDURE OCEGetRecipientType*((*CONST*)VAR cid: OCE.CreationID): Types.OSType;
  1203.     (*$IF NOT GENERATINGCFM*)
  1204.     INLINE PASCAL $303C, 834, $AA5C;
  1205.     (*$END*)
  1206. (*
  1207. Set the OCERecipient's extensionType in the specified cid.  (Note: we do NOT
  1208. check for a nil pointer).  If the extensionType is LONG("entn"), the cid is assumed
  1209. to be "valid" and is not touched.  Note*: to properly handle non LONG("entn")'s this
  1210. routine must and will zero the high long (source) of the cid! Safe to pass
  1211. dereferenced handle(s).
  1212. *)
  1213. PROCEDURE OCESetRecipientType*(extensionType: Types.OSType; VAR cid: OCE.CreationID);
  1214.     (*$IF NOT GENERATINGCFM*)
  1215.     INLINE PASCAL $303C, 835, $AA5C;
  1216.     (*$END*)
  1217.  
  1218. (* $ALIGN RESET*)
  1219. (* $POP*)
  1220.  
  1221.  END OCEMessaging.
  1222.